juce/source/extras/the jucer/src/model/components/jucer_ViewportHandler.h

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #ifndef __JUCER_VIEWPORTHANDLER_JUCEHEADER__
  27 #define __JUCER_VIEWPORTHANDLER_JUCEHEADER__
  28
  29
  30 //==============================================================================
  31 /**
  32 */
  33 class ViewportHandler  : public ComponentTypeHandler
  34 {
  35 public:
  36     //==============================================================================
  37     ViewportHandler()
  38         : ComponentTypeHandler ("Viewport", "Viewport", typeid (UpdatingViewport), 150, 150)
  39     {}
  40
  41     //==============================================================================
  42     Component* createNewComponent (JucerDocument*)
  43     {
  44         Viewport* const v = new UpdatingViewport ("new viewport");
  45         v->setViewedComponent (new ViewportDemoContentComp());
  46
  47         return v;
  48     }
  49
  50     XmlElement* createXmlFor (Component* comp, const ComponentLayout* layout)
  51     {
  52         Viewport* const v = dynamic_cast <Viewport*> (comp);
  53         XmlElement* const e = ComponentTypeHandler::createXmlFor (comp, layout);
  54
  55         e->setAttribute ("vscroll", v->isVerticalScrollBarShown());
  56         e->setAttribute ("hscroll", v->isHorizontalScrollBarShown());
  57         e->setAttribute ("scrollbarThickness", v->getScrollBarThickness());
  58
  59         e->setAttribute ("contentType", getViewportContentType (v));
  60         e->setAttribute ("jucerFile", getViewportJucerComponentFile (v));
  61         e->setAttribute ("contentClass", getViewportGenericComponentClass (v));
  62         e->setAttribute ("constructorParams", getViewportConstructorParams (v));
  63
  64         return e;
  65     }
  66
  67     bool restoreFromXml (const XmlElement& xml, Component* comp, const ComponentLayout* layout)
  68     {
  69         if (! ComponentTypeHandler::restoreFromXml (xml, comp, layout))
  70             return false;
  71
  72         Viewport defaultViewport;
  73         Viewport* const v = dynamic_cast <Viewport*> (comp);
  74         v->setScrollBarsShown (xml.getBoolAttribute ("vscroll", defaultViewport.isVerticalScrollBarShown()),
  75                                xml.getBoolAttribute ("hscroll", defaultViewport.isHorizontalScrollBarShown()));
  76
  77         v->setScrollBarThickness (xml.getIntAttribute ("scrollbarThickness", defaultViewport.getScrollBarThickness()));
  78
  79         setViewportJucerComponentFile (v, xml.getStringAttribute ("jucerFile", String::empty));
  80         setViewportGenericComponentClass (v, xml.getStringAttribute ("contentClass"));
  81         setViewportContentType (v, xml.getIntAttribute ("contentType", 0));
  82         setViewportConstructorParams (v, xml.getStringAttribute ("constructorParams"));
  83
  84         return true;
  85     }
  86
  87     void getEditableProperties (Component* component, JucerDocument& document, Array <PropertyComponent*>& properties)
  88     {
  89         ComponentTypeHandler::getEditableProperties (component, document, properties);
  90
  91         Viewport* const v = dynamic_cast <Viewport*> (component);
  92
  93         properties.add (new ViewportScrollbarShownProperty (v, document, true));
  94         properties.add (new ViewportScrollbarShownProperty (v, document, false));
  95         properties.add (new ViewportScrollbarSizeProperty (v, document));
  96         properties.add (new ViewportContentTypeProperty (v, document));
  97
  98         if (getViewportContentType (v) == 1)
  99         {
 100             properties.add (new ViewportJucerFileProperty (v, document));
 101             properties.add (new ConstructorParamsProperty (v, document));
 102         }
 103         else if (getViewportContentType (v) == 2)
 104         {
 105             properties.add (new ViewportContentClassProperty (v, document));
 106             properties.add (new ConstructorParamsProperty (v, document));
 107         }
 108     }
 109
 110     const String getCreationParameters (Component* comp)
 111     {
 112         return quotedString (comp->getName());
 113     }
 114
 115     void fillInCreationCode (GeneratedCode& code, Component* component, const String& memberVariableName)
 116     {
 117         Viewport defaultViewport;
 118         Viewport* const v = dynamic_cast <Viewport*> (component);
 119
 120         ComponentTypeHandler::fillInCreationCode (code, component, memberVariableName);
 121
 122         if (defaultViewport.isVerticalScrollBarShown() != v->isVerticalScrollBarShown()
 123              || defaultViewport.isHorizontalScrollBarShown() != v->isHorizontalScrollBarShown())
 124         {
 125             code.constructorCode
 126                 << memberVariableName << "->setScrollBarsShown ("
 127                 << boolToString (v->isVerticalScrollBarShown()) << ", "
 128                 << boolToString (v->isHorizontalScrollBarShown()) << ");\n";
 129         }
 130
 131         if (defaultViewport.getScrollBarThickness() != v->getScrollBarThickness())
 132         {
 133             code.constructorCode
 134                 << memberVariableName << "->setScrollBarThickness ("
 135                 << v->getScrollBarThickness() << ");\n";
 136         }
 137
 138         if (getViewportContentType (v) != 0)
 139         {
 140             String className (getViewportGenericComponentClass (v));
 141
 142             if (getViewportContentType (v) == 1)
 143             {
 144                 File file;
 145
 146                 const String filename (getViewportJucerComponentFile (v));
 147
 148                 if (filename.isNotEmpty())
 149                     file = code.document->getFile().getSiblingFile (filename);
 150
 151                 JucerDocument* doc = ObjectTypes::loadDocumentFromFile (file, false);
 152
 153                 if (doc != 0)
 154                 {
 155                     code.includeFilesCPP.add (doc->getFile().withFileExtension ("h")
 156                                                 .getRelativePathFrom (code.document->getFile().getParentDirectory())
 157                                                 .replaceCharacter ('\\', '/'));
 158
 159                     className = doc->getClassName();
 160                     delete doc;
 161                 }
 162                 else
 163                 {
 164                     className = String::empty;
 165                 }
 166             }
 167
 168             if (className.isNotEmpty())
 169             {
 170                 code.constructorCode
 171                     << memberVariableName << "->setViewedComponent (new "
 172                     << className;
 173
 174                 if (getViewportConstructorParams (v).trim().isNotEmpty())
 175                 {
 176                     code.constructorCode << " (" << getViewportConstructorParams (v).trim() << "));\n";
 177                 }
 178                 else
 179                 {
 180                     code.constructorCode << "());\n";
 181                 }
 182             }
 183         }
 184
 185         code.constructorCode << "\n";
 186     }
 187
 188     static void updateViewportContentComp (Viewport* vp)
 189     {
 190         if (getViewportContentType (vp) == 1)
 191         {
 192             JucerDocument* doc = findParentDocument (vp);
 193             TestComponent* tc = new TestComponent (doc, 0, false);
 194
 195             tc->setFilename (getViewportJucerComponentFile (vp));
 196             tc->setToInitialSize();
 197
 198             vp->setViewedComponent (tc);
 199         }
 200         else
 201         {
 202             vp->setViewedComponent (new ViewportDemoContentComp());
 203         }
 204     }
 205
 206     static int getViewportContentType (Viewport* vp)
 207     {
 208         return vp->getProperties() ["contentType"];
 209     }
 210
 211     static void setViewportContentType (Viewport* vp, int newValue)
 212     {
 213         if (newValue != getViewportContentType (vp))
 214         {
 215             vp->getProperties().set ("contentType", newValue);
 216             updateViewportContentComp (vp);
 217         }
 218     }
 219
 220     static const String getViewportJucerComponentFile (Viewport* vp)
 221     {
 222         return vp->getProperties() ["jucerFile"].toString();
 223     }
 224
 225     static void setViewportJucerComponentFile (Viewport* vp, const String& file)
 226     {
 227         if (file != getViewportJucerComponentFile (vp))
 228         {
 229             vp->getProperties().set ("jucerFile", file);
 230             updateViewportContentComp (vp);
 231         }
 232     }
 233
 234     static const String getViewportGenericComponentClass (Viewport* vp)
 235     {
 236         return vp->getProperties() ["contentClass"].toString();
 237     }
 238
 239     static void setViewportGenericComponentClass (Viewport* vp, const String& className)
 240     {
 241         if (className != getViewportGenericComponentClass (vp))
 242         {
 243             vp->getProperties().set ("contentClass", className);
 244             updateViewportContentComp (vp);
 245         }
 246     }
 247
 248     static const String getViewportConstructorParams (Viewport* vp)
 249     {
 250         return vp->getProperties() ["constructorParams"].toString();
 251     }
 252
 253     static void setViewportConstructorParams (Viewport* vp, const String& newParams)
 254     {
 255         if (newParams != getViewportConstructorParams (vp))
 256         {
 257             vp->getProperties().set ("constructorParams", newParams);
 258             updateViewportContentComp (vp);
 259         }
 260     }
 261
 262 private:
 263     //==============================================================================
 264     class UpdatingViewport  : public Viewport
 265     {
 266     public:
 267         UpdatingViewport (const String& name)
 268             : Viewport (name)
 269         {
 270         }
 271
 272         void parentHierarchyChanged()
 273         {
 274             Viewport::parentHierarchyChanged();
 275             updateViewportContentComp (this);
 276         }
 277     };
 278
 279     //==============================================================================
 280     class ViewportDemoContentComp : public Component
 281     {
 282     public:
 283         ViewportDemoContentComp()
 284         {
 285             setSize (2048, 2048);
 286         }
 287
 288         void paint (Graphics& g)
 289         {
 290             g.fillCheckerBoard (getLocalBounds(), 50, 50,
 291                                 Colours::lightgrey.withAlpha (0.5f),
 292                                 Colours::darkgrey.withAlpha (0.5f));
 293         }
 294     };
 295
 296     //==============================================================================
 297     class ViewportScrollbarShownProperty  : public ComponentBooleanProperty <Viewport>
 298     {
 299     public:
 300         ViewportScrollbarShownProperty (Viewport* comp, JucerDocument& document, const bool vertical_)
 301             : ComponentBooleanProperty <Viewport> (vertical_ ? "V scrollbar" : "H scrollbar",
 302                                                    "enabled", "enabled",
 303                                                    comp, document),
 304                vertical (vertical_)
 305         {
 306         }
 307
 308         void setState (bool newState)
 309         {
 310             document.perform (new ViewportScrollbarChangeAction (component, *document.getComponentLayout(), vertical, newState),
 311                               "Change Viewport scrollbar");
 312         }
 313
 314         bool getState() const
 315         {
 316             return vertical ? component->isVerticalScrollBarShown()
 317                             : component->isHorizontalScrollBarShown();
 318         }
 319
 320         const bool vertical;
 321
 322     private:
 323         class ViewportScrollbarChangeAction  : public ComponentUndoableAction <Viewport>
 324         {
 325         public:
 326             ViewportScrollbarChangeAction (Viewport* const comp, ComponentLayout& layout, const bool vertical_, const bool newState_)
 327                 : ComponentUndoableAction <Viewport> (comp, layout),
 328                   vertical (vertical_),
 329                   newState (newState_)
 330             {
 331                 oldState = vertical ? comp->isVerticalScrollBarShown()
 332                                     : comp->isHorizontalScrollBarShown();
 333             }
 334
 335             bool perform()
 336             {
 337                 showCorrectTab();
 338                 if (vertical)
 339                     getComponent()->setScrollBarsShown (newState, getComponent()->isHorizontalScrollBarShown());
 340                 else
 341                     getComponent()->setScrollBarsShown (getComponent()->isVerticalScrollBarShown(), newState);
 342
 343                 changed();
 344                 return true;
 345             }
 346
 347             bool undo()
 348             {
 349                 showCorrectTab();
 350                 if (vertical)
 351                     getComponent()->setScrollBarsShown (oldState, getComponent()->isHorizontalScrollBarShown());
 352                 else
 353                     getComponent()->setScrollBarsShown (getComponent()->isVerticalScrollBarShown(), oldState);
 354                 changed();
 355                 return true;
 356             }
 357
 358             bool vertical, newState, oldState;
 359         };
 360     };
 361
 362     //==============================================================================
 363     class ViewportScrollbarSizeProperty  : public SliderPropertyComponent,
 364                                            public ChangeListener
 365     {
 366     public:
 367         ViewportScrollbarSizeProperty (Viewport* comp, JucerDocument& document_)
 368             : SliderPropertyComponent ("scrollbar size", 3.0, 30.0, 1.0, 1.0),
 369               component (comp),
 370               document (document_)
 371         {
 372             document.addChangeListener (this);
 373         }
 374
 375         ~ViewportScrollbarSizeProperty()
 376         {
 377             document.removeChangeListener (this);
 378         }
 379
 380         void setValue (double newValue)
 381         {
 382             document.getUndoManager().undoCurrentTransactionOnly();
 383
 384             document.perform (new ViewportScrollbarSizeChangeAction (component, *document.getComponentLayout(), roundToInt (newValue)),
 385                               "Change Viewport scrollbar size");
 386         }
 387
 388         double getValue() const
 389         {
 390             return component->getScrollBarThickness();
 391         }
 392
 393         void changeListenerCallback (ChangeBroadcaster*)
 394         {
 395             refresh();
 396         }
 397
 398         Viewport* component;
 399         JucerDocument& document;
 400
 401     private:
 402         class ViewportScrollbarSizeChangeAction  : public ComponentUndoableAction <Viewport>
 403         {
 404         public:
 405             ViewportScrollbarSizeChangeAction (Viewport* const comp, ComponentLayout& layout, const int newState_)
 406                 : ComponentUndoableAction <Viewport> (comp, layout),
 407                   newState (newState_)
 408             {
 409                 oldState = comp->getScrollBarThickness();
 410             }
 411
 412             bool perform()
 413             {
 414                 showCorrectTab();
 415                 getComponent()->setScrollBarThickness (newState);
 416                 changed();
 417                 return true;
 418             }
 419
 420             bool undo()
 421             {
 422                 showCorrectTab();
 423                 getComponent()->setScrollBarThickness (newState);
 424                 changed();
 425                 return true;
 426             }
 427
 428             int newState, oldState;
 429         };
 430     };
 431
 432     //==============================================================================
 433     class ViewportContentTypeProperty  : public ComponentChoiceProperty <Viewport>
 434     {
 435     public:
 436         ViewportContentTypeProperty (Viewport* comp, JucerDocument& document)
 437             : ComponentChoiceProperty <Viewport> ("content", comp, document)
 438         {
 439             choices.add ("No content component");
 440             choices.add ("Jucer content component");
 441             choices.add ("Named content component");
 442         }
 443
 444         void setIndex (int newIndex)
 445         {
 446             document.perform (new ViewportContentTypeChangeAction (component, *document.getComponentLayout(), newIndex),
 447                               "Change Viewport content type");
 448         }
 449
 450         int getIndex() const
 451         {
 452             return getViewportContentType (component);
 453         }
 454
 455     private:
 456         class ViewportContentTypeChangeAction  : public ComponentUndoableAction <Viewport>
 457         {
 458         public:
 459             ViewportContentTypeChangeAction (Viewport* const comp, ComponentLayout& layout, const int newValue_)
 460                 : ComponentUndoableAction <Viewport> (comp, layout),
 461                   newValue (newValue_)
 462             {
 463                 oldValue = getViewportContentType (comp);
 464             }
 465
 466             bool perform()
 467             {
 468                 showCorrectTab();
 469                 setViewportContentType (getComponent(), newValue);
 470                 changed();
 471                 layout.getDocument()->refreshAllPropertyComps();
 472                 return true;
 473             }
 474
 475             bool undo()
 476             {
 477                 showCorrectTab();
 478                 setViewportContentType (getComponent(), oldValue);
 479                 changed();
 480                 layout.getDocument()->refreshAllPropertyComps();
 481                 return true;
 482             }
 483
 484             int newValue, oldValue;
 485         };
 486     };
 487
 488     //==============================================================================
 489     class ViewportJucerFileProperty   : public FilePropertyComponent,
 490                                         public ChangeListener
 491     {
 492     public:
 493         ViewportJucerFileProperty (Viewport* const component_, JucerDocument& document_)
 494             : FilePropertyComponent ("Jucer file", false, true),
 495               component (component_),
 496               document (document_)
 497         {
 498             document.addChangeListener (this);
 499         }
 500
 501         ~ViewportJucerFileProperty()
 502         {
 503             document.removeChangeListener (this);
 504         }
 505
 506         //==============================================================================
 507         void setFile (const File& newFile)
 508         {
 509             document.perform (new JucerCompFileChangeAction (component, *document.getComponentLayout(),
 510                                                              newFile.getRelativePathFrom (document.getFile().getParentDirectory())
 511                                                                     .replaceCharacter ('\\', '/')
 512 ),
 513                               "Change Jucer component file");
 514         }
 515
 516         const File getFile() const
 517         {
 518             const String filename (getViewportJucerComponentFile (component));
 519
 520             if (filename.isEmpty())
 521                 return File::nonexistent;
 522
 523             return document.getFile().getSiblingFile (filename);
 524         }
 525
 526         void changeListenerCallback (ChangeBroadcaster*)
 527         {
 528             refresh();
 529         }
 530
 531     private:
 532         Viewport* const component;
 533         JucerDocument& document;
 534
 535         class JucerCompFileChangeAction  : public ComponentUndoableAction <Viewport>
 536         {
 537         public:
 538             JucerCompFileChangeAction (Viewport* const comp, ComponentLayout& layout, const String& newState_)
 539                 : ComponentUndoableAction <Viewport> (comp, layout),
 540                   newState (newState_)
 541             {
 542                 oldState = getViewportJucerComponentFile (comp);
 543             }
 544
 545             bool perform()
 546             {
 547                 showCorrectTab();
 548                 setViewportJucerComponentFile (getComponent(), newState);
 549                 changed();
 550                 return true;
 551             }
 552
 553             bool undo()
 554             {
 555                 showCorrectTab();
 556                 setViewportJucerComponentFile (getComponent(), oldState);
 557                 changed();
 558                 return true;
 559             }
 560
 561             String newState, oldState;
 562         };
 563     };
 564
 565     //==============================================================================
 566     class ViewportContentClassProperty   : public ComponentTextProperty <Viewport>
 567     {
 568     public:
 569         ViewportContentClassProperty (Viewport* comp, JucerDocument& document)
 570             : ComponentTextProperty <Viewport> ("content class", 256, false, comp, document)
 571         {
 572         }
 573
 574         void setText (const String& newText)
 575         {
 576             document.perform (new ViewportClassNameChangeAction (component, *document.getComponentLayout(), newText),
 577                               "Change Viewport content class");
 578         }
 579
 580         const String getText() const
 581         {
 582             return getViewportGenericComponentClass (component);
 583         }
 584
 585     private:
 586         class ViewportClassNameChangeAction  : public ComponentUndoableAction <Viewport>
 587         {
 588         public:
 589             ViewportClassNameChangeAction (Viewport* const comp, ComponentLayout& layout, const String& newValue_)
 590                 : ComponentUndoableAction <Viewport> (comp, layout),
 591                   newValue (newValue_)
 592             {
 593                 oldValue = getViewportGenericComponentClass (comp);
 594             }
 595
 596             bool perform()
 597             {
 598                 showCorrectTab();
 599                 setViewportGenericComponentClass (getComponent(), newValue);
 600                 changed();
 601                 layout.getDocument()->refreshAllPropertyComps();
 602                 return true;
 603             }
 604
 605             bool undo()
 606             {
 607                 showCorrectTab();
 608                 setViewportGenericComponentClass (getComponent(), oldValue);
 609                 changed();
 610                 layout.getDocument()->refreshAllPropertyComps();
 611                 return true;
 612             }
 613
 614             String newValue, oldValue;
 615         };
 616     };
 617
 618     //==============================================================================
 619     class ConstructorParamsProperty   : public ComponentTextProperty <Viewport>
 620     {
 621     public:
 622         ConstructorParamsProperty (Viewport* comp, JucerDocument& document)
 623             : ComponentTextProperty <Viewport> ("constructor params", 512, false, comp, document)
 624         {
 625         }
 626
 627         void setText (const String& newText)
 628         {
 629             document.perform (new ConstructorParamChangeAction (component, *document.getComponentLayout(), newText),
 630                               "Change Viewport content constructor params");
 631         }
 632
 633         const String getText() const
 634         {
 635             return getViewportConstructorParams (component);
 636         }
 637
 638     private:
 639         int tabIndex;
 640
 641         class ConstructorParamChangeAction  : public ComponentUndoableAction <Viewport>
 642         {
 643         public:
 644             ConstructorParamChangeAction (Viewport* const comp, ComponentLayout& layout, const String& newValue_)
 645                 : ComponentUndoableAction <Viewport> (comp, layout),
 646                   newValue (newValue_)
 647             {
 648                 oldValue = getViewportConstructorParams (comp);
 649             }
 650
 651             bool perform()
 652             {
 653                 showCorrectTab();
 654                 setViewportConstructorParams (getComponent(), newValue);
 655                 changed();
 656                 layout.getDocument()->refreshAllPropertyComps();
 657                 return true;
 658             }
 659
 660             bool undo()
 661             {
 662                 showCorrectTab();
 663                 setViewportConstructorParams (getComponent(), oldValue);
 664                 changed();
 665                 layout.getDocument()->refreshAllPropertyComps();
 666                 return true;
 667             }
 668
 669             String newValue, oldValue;
 670         };
 671     };
 672 };
 673
 674
 675 #endif   // __JUCER_VIEWPORTHANDLER_JUCEHEADER__